GridPACK: esst4b.hpp Source File

00001 /*
00002  *    Copyright (c) 2013 Battelle Memorial Institute
00003  *    Licensed under modified BSD License. A copy of this license can be found
00004  *    in the LICENSE file in the top level directory of this distribution.
00005  */
00006 /*
00007  *  Created on: June 20, 2016
00008  *      Author: Bruce Palmer
00009  */
00010 #ifndef ESST4B_HPP
00011 #define ESST4B_HPP
00012 #include "gridpack/component/data_collection.hpp"
00013 #include "gridpack/parser/dictionary.hpp"
00014 #include "gridpack/utilities/string_utils.hpp"
00015 namespace gridpack {
00016 namespace parser {
00017 template <class _data_struct> class Esst4bParser
00018 {
00019   public:
00020     /**
00021      * Constructor
00022      */
00023     explicit Esst4bParser()
00024     {
00025     }
00026 
00027     /**
00028      * Destructor
00029      */
00030     virtual ~Esst4bParser()
00031     {
00032     }
00033 
00034     /**
00035      * Extract data from _data_struct and store it in data collection object
00036      * @param data_struct data struct object
00037      * @param data data collection object
00038      * @param gen_id index of generator
00039      */
00040     void extract(_data_struct &data_struct,
00041         gridpack::component::DataCollection *data, int g_id)
00042     {
00043       double rval;
00044       bool bval;
00045       // HAS_EXCITER
00046       if (!data->getValue(HAS_EXCITER,&bval,g_id)) {
00047         data->addValue(HAS_EXCITER, true, g_id);
00048       } else {
00049         data->setValue(HAS_EXCITER, true, g_id);
00050       }
00051 
00052       // EXCITER_MODEL
00053       std::string stmp;
00054       if (!data->getValue(EXCITER_MODEL, &stmp, g_id)) {
00055         data->addValue(EXCITER_MODEL, data_struct.model, g_id);
00056       } else {
00057         data->setValue(EXCITER_MODEL, data_struct.model, g_id);
00058       }
00059 
00060       // EXCITER_TR
00061       if (!data->getValue(EXCITER_TR,&rval,g_id)) {
00062         data->addValue(EXCITER_TR, data_struct.ex_tr, g_id);
00063       } else {
00064         data->setValue(EXCITER_TR, data_struct.ex_tr, g_id);
00065       }
00066 
00067       // EXCITER_KPR
00068       if (!data->getValue(EXCITER_KPR,&rval,g_id)) {
00069         data->addValue(EXCITER_KPR, data_struct.kpr, g_id);
00070       } else {
00071         data->setValue(EXCITER_KPR, data_struct.kpr, g_id);
00072       }
00073 
00074       // EXCITER_KIR
00075       if (!data->getValue(EXCITER_KIR,&rval,g_id)) {
00076         data->addValue(EXCITER_KIR, data_struct.kir, g_id);
00077       } else {
00078         data->setValue(EXCITER_KIR, data_struct.kir, g_id);
00079       }
00080 
00081       // EXCITER_VRMAX
00082       if (!data->getValue(EXCITER_VRMAX,&rval,g_id)) {
00083         data->addValue(EXCITER_VRMAX, data_struct.vrmax, g_id);
00084       } else {
00085         data->setValue(EXCITER_VRMAX, data_struct.vrmax, g_id);
00086       }
00087 
00088       // EXCITER_VRMIN
00089       if (!data->getValue(EXCITER_VRMIN,&rval,g_id)) {
00090         data->addValue(EXCITER_VRMIN, data_struct.vrmin, g_id);
00091       } else {
00092         data->setValue(EXCITER_VRMIN, data_struct.vrmin, g_id);
00093       }
00094 
00095       // EXCITER_TA
00096       if (!data->getValue(EXCITER_TA,&rval,g_id)) {
00097         data->addValue(EXCITER_TA, data_struct.ex_ta, g_id);
00098       } else {
00099         data->setValue(EXCITER_TA, data_struct.ex_ta, g_id);
00100       }
00101 
00102       // EXCITER_KPM
00103       if (!data->getValue(EXCITER_KPM,&rval,g_id)) {
00104         data->addValue(EXCITER_KPM, data_struct.kpm, g_id);
00105       } else {
00106         data->setValue(EXCITER_KPM, data_struct.kpm, g_id);
00107       }
00108 
00109       // EXCITER_KIM
00110       if (!data->getValue(EXCITER_KIM,&rval,g_id)) {
00111         data->addValue(EXCITER_KIM, data_struct.kim, g_id);
00112       } else {
00113         data->setValue(EXCITER_KIM, data_struct.kim, g_id);
00114       }
00115 
00116       // EXCITER_VMMAX
00117       if (!data->getValue(EXCITER_VMMAX,&rval,g_id)) {
00118         data->addValue(EXCITER_VMMAX, data_struct.vmmax, g_id);
00119       } else {
00120         data->setValue(EXCITER_VMMAX, data_struct.vmmax, g_id);
00121       }
00122 
00123       // EXCITER_VMMIN
00124       if (!data->getValue(EXCITER_VMMIN,&rval,g_id)) {
00125         data->addValue(EXCITER_VMMIN, data_struct.vmmin, g_id);
00126       } else {
00127         data->setValue(EXCITER_VMMIN, data_struct.vmmin, g_id);
00128       }
00129 
00130       // EXCITER_KG
00131       if (!data->getValue(EXCITER_KG,&rval,g_id)) {
00132         data->addValue(EXCITER_KG, data_struct.ex_kg, g_id);
00133       } else {
00134         data->setValue(EXCITER_KG, data_struct.ex_kg, g_id);
00135       }
00136 
00137       // EXCITER_KP
00138       if (!data->getValue(EXCITER_KP,&rval,g_id)) {
00139         data->addValue(EXCITER_KP, data_struct.ex_kp, g_id);
00140       } else {
00141         data->setValue(EXCITER_KP, data_struct.ex_kp, g_id);
00142       }
00143 
00144       // EXCITER_KI
00145       if (!data->getValue(EXCITER_KI,&rval,g_id)) {
00146         data->addValue(EXCITER_KI, data_struct.ex_ki, g_id);
00147       } else {
00148         data->setValue(EXCITER_KI, data_struct.ex_ki, g_id);
00149       }
00150 
00151       // EXCITER_VBMAX
00152       if (!data->getValue(EXCITER_VBMAX,&rval,g_id)) {
00153         data->addValue(EXCITER_VBMAX, data_struct.vbmax, g_id);
00154       } else {
00155         data->setValue(EXCITER_VBMAX, data_struct.vbmax, g_id);
00156       }
00157 
00158       // EXCITER_KC
00159       if (!data->getValue(EXCITER_KC,&rval,g_id)) {
00160         data->addValue(EXCITER_KC, data_struct.ex_kc, g_id);
00161       } else {
00162         data->setValue(EXCITER_KC, data_struct.ex_kc, g_id);
00163       }
00164 
00165       // EXCITER_XL
00166       if (!data->getValue(EXCITER_XL,&rval,g_id)) {
00167         data->addValue(EXCITER_XL, data_struct.ex_xl, g_id);
00168       } else {
00169         data->setValue(EXCITER_XL, data_struct.ex_xl, g_id);
00170       }
00171 
00172       // EXCITER_THETAP
00173       if (!data->getValue(EXCITER_THETAP,&rval,g_id)) {
00174         data->addValue(EXCITER_THETAP, data_struct.thetap, g_id);
00175       } else {
00176         data->setValue(EXCITER_THETAP, data_struct.thetap, g_id);
00177       }
00178     }
00179 
00180     /**
00181      * Parser list of strings and store results in data collection object
00182      * @param split_line list of tokens from .dyr file
00183      * @param data data collection object
00184      * @param gen_id index of generator
00185      */
00186     void parse(std::vector<std::string> &split_line,
00187         gridpack::component::DataCollection *data, int g_id)
00188     {
00189       double rval;
00190       bool bval;
00191       int nstr = split_line.size();
00192       // HAS_EXCITER
00193       if (!data->getValue(HAS_EXCITER,&bval,g_id)) {
00194         data->addValue(HAS_EXCITER, true, g_id);
00195       } else {
00196         data->setValue(HAS_EXCITER, true, g_id);
00197       }
00198 
00199       // EXCITER_MODEL
00200       std::string stmp, model;
00201       gridpack::utility::StringUtils util;
00202       model = util.trimQuotes(split_line[1]);
00203       util.toUpper(model);
00204       if (!data->getValue(EXCITER_MODEL,&stmp,g_id)) {
00205         data->addValue(EXCITER_MODEL, model.c_str(), g_id);
00206       } else {
00207         data->setValue(EXCITER_MODEL, model.c_str(), g_id);
00208       }
00209 
00210       // EXCITER_TR
00211       if (nstr > 3) {
00212         if (!data->getValue(EXCITER_TR,&rval,g_id)) {
00213           data->addValue(EXCITER_TR,
00214               atof(split_line[3].c_str()), g_id);
00215         } else {
00216           data->setValue(EXCITER_TR,
00217               atof(split_line[3].c_str()), g_id);
00218         }
00219       } 
00220 
00221       // EXCITER_KPR
00222       if (nstr > 4) {
00223         if (!data->getValue(EXCITER_KPR,&rval,g_id)) {
00224           data->addValue(EXCITER_KPR,
00225               atof(split_line[4].c_str()), g_id);
00226         } else {
00227           data->setValue(EXCITER_KPR,
00228               atof(split_line[4].c_str()), g_id);
00229         }
00230       } 
00231 
00232       // EXCITER_KIR
00233       if (nstr > 5) {
00234         if (!data->getValue(EXCITER_KIR,&rval,g_id)) {
00235           data->addValue(EXCITER_KIR,
00236               atof(split_line[5].c_str()), g_id);
00237         } else {
00238           data->setValue(EXCITER_KIR,
00239               atof(split_line[5].c_str()), g_id);
00240         }
00241       }
00242 
00243       // EXCITER_VRMAX
00244       if (nstr > 6) {
00245         if (!data->getValue(EXCITER_VRMAX,&rval,g_id)) {
00246           data->addValue(EXCITER_VRMAX,
00247               atof(split_line[6].c_str()), g_id);
00248         } else {
00249           data->setValue(EXCITER_VRMAX,
00250               atof(split_line[6].c_str()), g_id);
00251         }
00252       }
00253 
00254       // EXCITER_VRMIN
00255       if (nstr > 7) {
00256         if (!data->getValue(EXCITER_VRMIN,&rval,g_id)) {
00257           data->addValue(EXCITER_VRMIN,
00258               atof(split_line[7].c_str()), g_id);
00259         } else {
00260           data->setValue(EXCITER_VRMIN,
00261               atof(split_line[7].c_str()), g_id);
00262         }
00263       }
00264 
00265       // EXCITER_TA
00266       if (nstr > 8) {
00267         if (!data->getValue(EXCITER_TA,&rval,g_id)) {
00268           data->addValue(EXCITER_TA,
00269               atof(split_line[8].c_str()), g_id);
00270         } else {
00271           data->setValue(EXCITER_TA,
00272               atof(split_line[8].c_str()), g_id);
00273         }
00274       } 
00275 
00276       // EXCITER_KPM
00277       if (nstr > 9) {
00278         if (!data->getValue(EXCITER_KPM,&rval,g_id)) {
00279           data->addValue(EXCITER_KPM,
00280               atof(split_line[9].c_str()), g_id);
00281         } else {
00282           data->setValue(EXCITER_KPM,
00283               atof(split_line[9].c_str()), g_id);
00284         }
00285       } 
00286 
00287       // EXCITER_KIM
00288       if (nstr > 10) {
00289         if (!data->getValue(EXCITER_KIM,&rval,g_id)) {
00290           data->addValue(EXCITER_KIM,
00291               atof(split_line[10].c_str()), g_id);
00292         } else {
00293           data->setValue(EXCITER_KIM,
00294               atof(split_line[10].c_str()), g_id);
00295         }
00296       } 
00297 
00298       // EXCITER_VMMAX
00299       if (nstr > 11) {
00300         if (!data->getValue(EXCITER_VMMAX,&rval,g_id)) {
00301           data->addValue(EXCITER_VMMAX,
00302               atof(split_line[11].c_str()), g_id);
00303         } else {
00304           data->setValue(EXCITER_VMMAX,
00305               atof(split_line[11].c_str()), g_id);
00306         }
00307       } 
00308 
00309       // EXCITER_VMMIN
00310       if (nstr > 12) {
00311         if (!data->getValue(EXCITER_VMMIN,&rval,g_id)) {
00312           data->addValue(EXCITER_VMMIN,
00313               atof(split_line[12].c_str()), g_id);
00314         } else {
00315           data->setValue(EXCITER_VMMIN,
00316               atof(split_line[12].c_str()), g_id);
00317         }
00318       } 
00319 
00320       // EXCITER_KG
00321       if (nstr > 13) {
00322         if (!data->getValue(EXCITER_KG,&rval,g_id)) {
00323           data->addValue(EXCITER_KG,
00324               atof(split_line[13].c_str()), g_id);
00325         } else {
00326           data->setValue(EXCITER_KG,
00327               atof(split_line[13].c_str()), g_id);
00328         }
00329       } 
00330 
00331       // EXCITER_KP
00332       if (nstr > 14) {
00333         if (!data->getValue(EXCITER_KP,&rval,g_id)) {
00334           data->addValue(EXCITER_KP,
00335               atof(split_line[14].c_str()), g_id);
00336         } else {
00337           data->setValue(EXCITER_KP,
00338               atof(split_line[14].c_str()), g_id);
00339         }
00340       } 
00341 
00342       // EXCITER_KI
00343       if (nstr > 15) {
00344         if (!data->getValue(EXCITER_KI,&rval,g_id)) {
00345           data->addValue(EXCITER_KI,
00346               atof(split_line[15].c_str()), g_id);
00347         } else {
00348           data->setValue(EXCITER_KI,
00349               atof(split_line[15].c_str()), g_id);
00350         }
00351       } 
00352 
00353       // EXCITER_VBMAX
00354       if (nstr > 16) {
00355         if (!data->getValue(EXCITER_VBMAX,&rval,g_id)) {
00356           data->addValue(EXCITER_VBMAX,
00357               atof(split_line[16].c_str()), g_id);
00358         } else {
00359           data->setValue(EXCITER_VBMAX,
00360               atof(split_line[16].c_str()), g_id);
00361         }
00362       } 
00363 
00364       // EXCITER_KC
00365       if (nstr > 17) {
00366         if (!data->getValue(EXCITER_KC,&rval,g_id)) {
00367           data->addValue(EXCITER_KC,
00368               atof(split_line[17].c_str()), g_id);
00369         } else {
00370           data->setValue(EXCITER_KC,
00371               atof(split_line[17].c_str()), g_id);
00372         }
00373       } 
00374 
00375       // EXCITER_XL
00376       if (nstr > 18) {
00377         if (!data->getValue(EXCITER_XL,&rval,g_id)) {
00378           data->addValue(EXCITER_XL,
00379               atof(split_line[18].c_str()), g_id);
00380         } else {
00381           data->setValue(EXCITER_XL,
00382               atof(split_line[18].c_str()), g_id);
00383         }
00384       } 
00385 
00386       // EXCITER_THETAP
00387       if (nstr > 19) {
00388         if (!data->getValue(EXCITER_THETAP,&rval,g_id)) {
00389           data->addValue(EXCITER_THETAP,
00390               atof(split_line[19].c_str()), g_id);
00391         } else {
00392           data->setValue(EXCITER_THETAP,
00393               atof(split_line[19].c_str()), g_id);
00394         }
00395       } 
00396     }
00397 
00398     /**
00399      * Parse list of strings store results in data_struct object
00400      * @param split_line list of tokens from .dyr file
00401      * @param data data struct that stores information from file
00402      */
00403     void store(std::vector<std::string> &split_line,_data_struct &data)
00404     {
00405       // EXCITER_BUSNUMBER               "I"                   integer
00406       int o_idx;
00407       o_idx = atoi(split_line[0].c_str());
00408       data.bus_id = o_idx;
00409 
00410       // Clean up 2 character tag for generator ID
00411       gridpack::utility::StringUtils util;
00412       std::string tag = util.clean2Char(split_line[2]);
00413       strcpy(data.gen_id, tag.c_str());
00414 
00415       std::string sval;
00416 
00417       sval = util.trimQuotes(split_line[1]);
00418       util.toUpper(sval);
00419 
00420       // EXCITER_MODEL              "MODEL"                  integer
00421       strcpy(data.model, sval.c_str());
00422 
00423       int nstr = split_line.size();
00424       // EXCITER_TR
00425       if (nstr > 3) {
00426         data.ex_tr = atof(split_line[3].c_str());
00427       }
00428 
00429       // EXCITER_KPR
00430       if (nstr > 4) {
00431         data.kpr = atof(split_line[4].c_str());
00432       }
00433 
00434       // EXCITER_KIR
00435       if (nstr > 5) {
00436         data.kir = atof(split_line[5].c_str());
00437       }
00438 
00439       // EXCITER_VRMAX
00440       if (nstr > 6) {
00441         data.vrmax = atof(split_line[6].c_str());
00442       }
00443 
00444       // EXCITER_VRMIN
00445       if (nstr > 7) {
00446         data.vrmin = atof(split_line[7].c_str());
00447       }
00448 
00449       // EXCITER_TA
00450       if (nstr > 8) {
00451         data.ex_ta = atof(split_line[8].c_str());
00452       }
00453 
00454       // EXCITER_KPM
00455       if (nstr > 9) {
00456         data.kpm = atof(split_line[9].c_str());
00457       }
00458 
00459       // EXCITER_KIM
00460       if (nstr > 10) {
00461         data.kim = atof(split_line[10].c_str());
00462       }
00463 
00464       // EXCITER_VMMAX
00465       if (nstr > 11) {
00466         data.vmmax = atof(split_line[11].c_str());
00467       }
00468 
00469       // EXCITER_VMMIN
00470       if (nstr > 12) {
00471         data.vmmin = atof(split_line[12].c_str());
00472       }
00473 
00474       // EXCITER_KG
00475       if (nstr > 13) {
00476         data.ex_kg = atof(split_line[13].c_str());
00477       }
00478 
00479       // EXCITER_KP
00480       if (nstr > 14) {
00481         data.ex_kp = atof(split_line[14].c_str());
00482       }
00483 
00484       // EXCITER_KI
00485       if (nstr > 15) {
00486         data.ex_ki = atof(split_line[15].c_str());
00487       }
00488 
00489       // EXCITER_VBMAX
00490       if (nstr > 16) {
00491         data.vbmax = atof(split_line[16].c_str());
00492       }
00493 
00494       // EXCITER_KC
00495       if (nstr > 17) {
00496         data.ex_kc = atof(split_line[17].c_str());
00497       }
00498 
00499       // EXCITER_XL
00500       if (nstr > 18) {
00501         data.ex_xl = atof(split_line[18].c_str());
00502       }
00503 
00504       // EXCITER_THETAP
00505       if (nstr > 19) {
00506         data.thetap = atof(split_line[19].c_str());
00507       }
00508     }
00509 };
00510 }  // parser
00511 }  // gridpack
00512 #endif